import axios from 'axios'
import Cookies from 'js-cookie'
import { Notification, MessageBox, Message } from 'element-ui'
// import store from '@/store'
import { getToken, removeToken, getRefreshToken, setRefreshToken , setToken, removeRefreshToken } from '@/utils/auth'
import errorCode from '@/utils/errorCode'
import config, { log } from '@/config'


// axios.defaults.headers['Content-Type'] = 'application/json;charset=utf-8'
// 创建axios实例

// 创建axios实例
const request = axios.create({
    // axios中请求配置有baseURL选项，表示请求URL公共部分
    baseURL: config.baseApi || window.baseUrl || '',
    // 超时
    timeout: config.timeout || 60000
})

// 打印baseURL配置，帮助调试
if (process.env.NODE_ENV === 'development') {
    log.info('Axios baseURL配置:', request.defaults.baseURL);
    log.info('config.baseApi:', config.baseApi);
    log.info('window.baseUrl值:', window.baseUrl);
}

// 强制设置baseURL，确保每次请求前都使用最新的window.baseUrl
request.interceptors.request.use(function(config) {
    // 每次请求前强制设置baseURL为config.baseApi或window.baseUrl
    const baseUrl = window.config?.baseApi || window.baseUrl;
    if (baseUrl) {
        config.baseURL = baseUrl;
    }
    return config;
}, function(error) {
    return Promise.reject(error);
}, { runWhen: () => true, synchronous: true });

// 记录请求重试次数
const requestRetryCount = new Map();

// 用于控制token刷新的变量
let isRefreshing = false; // 标记是否正在刷新token
let refreshSubscribers = []; // 存储待重发请求
let isShowingLoginDialog = false; // 标记是否已经显示了登录过期提示框

// 仅在开发环境显示日志
const isDev = process.env.NODE_ENV === 'development';

// 调试日志函数
function debugRequest(msg, config) {
    if (isDev) {
        log.debug(`${msg}:`, {
            url: config.url,
            baseURL: config.baseURL,
            完整URL: config.baseURL ? `${config.baseURL}${config.url}` : config.url,
            method: config.method
        });
    }
}

// 处理刷新完成后的重发请求
function onRefreshed(token) {
    // 重发队列中的请求
    refreshSubscribers.forEach(callback => callback(token));
    // 清空队列
    refreshSubscribers = [];
}

// 添加请求到队列
function addSubscriber(callback) {
    refreshSubscribers.push(callback);
}

// request拦截器
request.interceptors.request.use(config => {
    // 请求前调试
    debugRequest('请求前', config);
    
    // 确保使用正确的baseURL
    if (window.baseUrl) {
        // 如果URL是完整的localhost地址
        if (config.url && (config.url.startsWith('http://localhost') || config.url.startsWith('https://localhost'))) {
            // 提取路径部分
            try {
                const urlObj = new URL(config.url);
                config.url = urlObj.pathname + urlObj.search;
                config.baseURL = window.baseUrl;
                if (isDev) {
                    log.info('已修正localhost URL:', window.baseUrl + config.url);
                }
            } catch (e) {
                if (isDev) {
                    log.error('URL解析错误:', e);
                }
            }
        }
        
        // 确保baseURL设置正确
        if (config.baseURL !== window.baseUrl) {
            config.baseURL = window.baseUrl;
            if (isDev) {
                log.info('已设置baseURL为:', window.baseUrl);
            }
        }
    }
    
    // 请求后调试
    debugRequest('修正后', config);
    
    // 是否需要设置 token
    const isToken = (config.headers || {}).isToken === false
    if (getToken() && !isToken) {
        config.headers.common['Authorization'] = "Bearer " + getToken() // 让每个请求携带自定义token 请根据实际情况自行修改
    }
    
    // 为每个请求生成一个唯一标识符
    const requestId = `${config.method}:${config.url}${config.params ? JSON.stringify(config.params) : ''}`;
    config.requestId = requestId;
    
    // 检查是否是重试请求，如果是，增加计数
    if (!requestRetryCount.has(requestId)) {
        requestRetryCount.set(requestId, 0);
    }
    
    // 记录请求时间
    config._requestTime = new Date().getTime();
    
    // get请求映射params参数
    if (config.method === 'get' && config.params) {
        let url = config.url + '?';
        for (const propName of Object.keys(config.params)) {
            const value = config.params[propName];
            var part = encodeURIComponent(propName) + "=";
            if (value !== null && typeof (value) !== "undefined") {
                if (typeof value === 'object') {
                    for (const key of Object.keys(value)) {
                        let params = propName + '[' + key + ']';
                        var subPart = encodeURIComponent(params) + "=";
                        url += subPart + encodeURIComponent(value[key]) + "&";
                    }
                } else {
                    url += part + encodeURIComponent(value) + "&";
                }
            }
        }
        url = url.slice(0, -1);
        config.params = {};
        config.url = url;
    }
    return config
}, error => {
    if (isDev) {
        log.error(error);
    }
    return Promise.reject(error);
})

// 刷新token的公共函数
function refreshTokenRequest(refreshToken) {
    // 判断使用哪种刷新方式
    const isJWTToken = refreshToken.length > 40;
    const baseUrl = config.baseApi || window.baseUrl || '';
    const endpoint = isJWTToken ? 
        `${baseUrl}/api/token/refresh/` : 
        `${baseUrl}/sso/refresh_token/`;
    
    if (isDev) {
        log.info(`使用${isJWTToken ? 'JWT' : 'SSO'}方式刷新token，请求地址: ${endpoint}`);
    }
    
    // 构建请求体
    const requestBody = isJWTToken ? 
        { refresh: refreshToken } : 
        { refresh_token: refreshToken };
    
    // 使用axios而非request发送请求，避免拦截器循环
    return axios.post(endpoint, requestBody, {
        headers: {
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        },
        timeout: config.timeout || 10000 // 使用配置的超时或默认10秒
    });
}

// 处理token刷新
function handleTokenRefresh(config) {
    // 使用getRefreshToken从auth.js获取刷新token
    const refreshToken = getRefreshToken();
    
    if (isDev) {
        log.info('准备刷新token, 配置:', { 
            url: config.url, 
            method: config.method,
            hasRefreshToken: !!refreshToken 
        });
    }
    
    if (!refreshToken) {
        if (isDev) {
            log.error('未找到刷新token，无法自动续期');
        }
        // 清除token
        removeToken();
        removeRefreshToken();
        // 显示登录框
        if (!isShowingLoginDialog) {
            isShowingLoginDialog = true;
            MessageBox.confirm('登录状态已过期，您可以继续留在该页面，或者重新登录', '系统提示', {
                confirmButtonText: '重新登录',
                cancelButtonText: '取消',
                type: 'warning'
            }).then(() => {
                location.href = '/index';
                isShowingLoginDialog = false;
            }).catch(() => {
                isShowingLoginDialog = false;
            });
        }
        return Promise.reject(new Error('未找到刷新token'));
    }
    
    // 如果正在刷新，将请求加入队列
    if (isRefreshing) {
        if (isDev) {
            log.info('已有token刷新请求正在进行，将当前请求加入队列');
        }
        return new Promise((resolve) => {
            addSubscriber(token => {
                if (isDev) {
                    log.info('队列中的请求收到新token，准备重发', { url: config.url });
                }
                // 重新设置Authorization
                config.headers = config.headers || {};
                config.headers.Authorization = `Bearer ${token}`;
                // 保证重试请求的标记一致
                config.isRetryRequest = true;
                resolve(request(config));
            });
        });
    }
    
    // 设置刷新标记
    isRefreshing = true;
    
    if (isDev) {
        log.info('正在刷新token...');
    }
    
    return refreshTokenRequest(refreshToken)
        .then(response => {
            if (isDev) {
                log.info('刷新token成功:', response.data);
            }
            
            // 根据刷新方式提取token
            const newToken = response.data.access || response.data.access_token;
            const newRefreshToken = response.data.refresh || response.data.refresh_token;
            
            if (!newToken) {
                if (isDev) {
                    log.error('刷新token响应中未找到新token:', response.data);
                }
                throw new Error('刷新token响应格式错误');
            }
            
            if (isDev) {
                log.info('获取到新token:', { 
                    token: newToken.substring(0, 10) + '...',
                    hasRefreshToken: !!newRefreshToken
                });
            }
            
            // 保存新token
            if (newToken) {
                setToken(newToken);
                if (isDev) {
                    log.info('已保存新token');
                }
            }
            if (newRefreshToken) {
                setRefreshToken(newRefreshToken);
                if (isDev) {
                    log.info('已保存新refresh token');
                }
            }
            
            // 通知所有等待的请求
            if (isDev) {
                log.info(`通知${refreshSubscribers.length}个等待中的请求`);
            }
            onRefreshed(newToken);
            
            // 重置刷新标记
            isRefreshing = false;
            
            // 重新设置Authorization
            config.headers = config.headers || {};
            config.headers.Authorization = `Bearer ${newToken}`;
            
            // 标记这是一个重试请求，避免进入无限循环
            config.isRetryRequest = true;
            
            // 清除可能导致重复计数的请求ID
            if (config.requestId) {
                requestRetryCount.delete(config.requestId);
            }
            
            // 为重发请求生成新的requestId
            const newRequestId = `${config.method}:${config.url}${config.params ? JSON.stringify(config.params) : ''}_retry_${Date.now()}`;
            config.requestId = newRequestId;
            requestRetryCount.set(newRequestId, 0);
            
            // 延迟100毫秒再重发请求，给浏览器一些时间处理token
            return new Promise(resolve => {
                setTimeout(() => {
                    if (isDev) {
                        log.info('使用新token重发原请求:', { url: config.url, method: config.method });
                    }
                    resolve(request(config));
                }, 100);
            });
        })
        .catch(error => {
            log.error('刷新token失败:', error);
            
            // 清空等待的请求
            log.info(`清空${refreshSubscribers.length}个等待中的请求`);
            refreshSubscribers = [];
            
            // 重置刷新标记
            isRefreshing = false;
            
            // 清除token
            removeToken();
            removeRefreshToken();
            log.info('已清除所有token');
            
            // 检查是否是invalid grant错误（密码错误）
            if (error.response && error.response.data && 
                (error.response.data.detail === "invalid grant" || 
                 error.response.data.error === "invalid_grant" ||
                 JSON.stringify(error.response.data).includes("invalid grant"))) {
                
                log.info('检测到invalid grant错误，提示用户密码错误');
                
                // 使用MessageBox替代Message，仅在用户确认后跳转
                if (!isShowingLoginDialog) {
                    isShowingLoginDialog = true;
                    MessageBox.confirm('用户或密码错误，请重新输入', '系统提示', {
                        confirmButtonText: '重新登录',
                        cancelButtonText: '取消',
                        type: 'warning'
                    }).then(() => {
                        location.href = '/index';
                        isShowingLoginDialog = false;
                    }).catch(() => {
                        log.info('用户选择留在当前页面');
                        isShowingLoginDialog = false;
                    });
                }
                
                return Promise.reject(new Error('用户或密码错误，请重新输入'));
            }
            
            // 检查是否是"No active account found with the given credentials"错误（用户不存在）
            if (error.response && error.response.data && 
                (error.response.data.detail === "No active account found with the given credentials" || 
                 JSON.stringify(error.response.data).includes("No active account found with the given credentials"))) {
                
                log.info('检测到用户名或密码错误');
                
                // 清除token
                removeToken();
                removeRefreshToken();
                
                // 显示消息并提供重新登录选项
                if (!isShowingLoginDialog) {
                    isShowingLoginDialog = true;
                    MessageBox.confirm('用户名或密码错误，请重新输入', '系统提示', {
                        confirmButtonText: '重新登录',
                        cancelButtonText: '取消',
                        type: 'warning'
                    }).then(() => {
                        location.href = '/index';
                        isShowingLoginDialog = false;
                    }).catch(() => {
                        log.info('用户选择留在当前页面');
                        isShowingLoginDialog = false;
                    });
                }
                
                return Promise.reject(new Error('用户名或密码错误，请重新输入'));
            }
            
            // 如果是刷新token接口返回401或token_not_valid，提示登录超时
            if (error.config && error.config.url && 
                (error.config.url.includes('/api/token/refresh/') || error.config.url.includes('/sso/refresh_token/')) &&
                ((error.response && error.response.status === 401) || 
                 (error.response && error.response.data && 
                  (error.response.data.code === "token_not_valid" || 
                   (error.response.data.detail && 
                    (error.response.data.detail === "Token is invalid or expired" || 
                     error.response.data.detail === "Given token not valid for any token type")))))) {
                
                log.info('刷新token请求失败，token无效，需要重新登录');
                
                // 显示登录超时提示并提供重新登录选项
                if (!isShowingLoginDialog) {
                    isShowingLoginDialog = true;
                    MessageBox.confirm('登录已超时，请重新登录', '系统提示', {
                        confirmButtonText: '确定',
                        cancelButtonText: '取消',
                        type: 'warning'
                    }).then(() => {
                        location.href = '/index';
                        isShowingLoginDialog = false;
                    }).catch(() => {
                        log.info('用户选择留在当前页面');
                        isShowingLoginDialog = false;
                    });
                }
                
                return Promise.reject(new Error('登录已超时，请重新登录'));
            }
            
            // 其他错误情况显示登录框，但保留选择权
            log.info('刷新token失败，显示选择对话框');
            if (!isShowingLoginDialog) {
                isShowingLoginDialog = true;
                MessageBox.confirm('登录状态已过期，您可以继续留在该页面，或者重新登录', '系统提示', {
                    confirmButtonText: '确定',
                    cancelButtonText: '取消',
                    type: 'warning'
                }).then(() => {
                    location.href = '/index';
                    isShowingLoginDialog = false;
                }).catch(() => {
                    log.info('用户选择留在当前页面');
                    isShowingLoginDialog = false;
                });
            }
            
            return Promise.reject(new Error('刷新token失败，请手动刷新页面'));
        });
}

// 响应拦截器
request.interceptors.response.use(res => {

    // 未设置状态码则默认成功状态
    var code = res.data?.code || 200;

    /* 新增代码Start-------岗位菜单中获取岗位详情，api或者的属性中包含了code属性，与请求中的code属性冲突，根据请求的数据类型区分两者 */
    if (typeof (res.data?.code) === 'string') {
        var code = 200
    }
    /* -------END 新增代码*/

    // 获取错误信息
    const msg = errorCode[code] || res.data.msg || errorCode['default']
    if (code === 401) {
        // 检查响应头部中是否有新token
        const newToken = res.headers && (res.headers['new-token'] || res.headers['New-Token']);
        if (newToken) {
            if (isDev) {
                log.info('响应头中发现新token，更新token');
            }
            setToken(newToken);
            // 使用新token重发请求
            const config = res.config;
            config.headers.Authorization = `Bearer ${newToken}`;
                    return request(config);
                }
        
        // 检查是否已经是重试请求，避免无限循环
        if (res.config.isRetryRequest) {
            // 已经重试过但仍然返回401，说明刷新token无效，需要重新登录
            removeToken();
            removeRefreshToken();
            
            if (isDev) {
                log.info('刷新token后请求仍返回401，需要重新登录');
            }
            if (!isShowingLoginDialog) {
                isShowingLoginDialog = true;
                MessageBox.confirm('登录已超时，请重新登录', '系统提示', {
                    confirmButtonText: '确定',
                    cancelButtonText: '取消',
                    type: 'warning'
                }).then(() => {
                    location.href = '/index';
                    isShowingLoginDialog = false;
                }).catch(() => {
                    if (isDev) {
                        log.info('用户选择留在当前页面');
                    }
                    isShowingLoginDialog = false;
                });
            }
            
            return Promise.reject(new Error('登录已超时，请重新登录'));
        }
        
        // 尝试刷新token
        return handleTokenRefresh(res.config);
    } else if (code === 500) {
        Message({
            message: msg,
            type: 'error'
        })
        return Promise.reject(new Error(msg))
    } else if (code !== 200) {
        // 检查是否是token刷新后的请求返回的其他错误码，如果是则不显示登录过期
        if (res.config.isRetryRequest) {
            if (isDev) {
                log.info('刷新token后的请求返回错误码:', code);
            }
            Notification.error({
                title: msg
            });
            return Promise.reject(new Error(msg));
        }
        
        Notification.error({
            title: msg
        })
        return Promise.reject('error')
    } else {
        return res.data
    }
},
    error => {
        if (isDev) {
            log.error('error', error);
        }
        
        // 检查是否存在响应对象，获取状态码
        const status = error.response ? error.response.status : null;
        
        // 获取请求标识符和重试次数
        const requestId = error.config?.requestId;
        let retryCount = 0;
        
        if (requestId) {
            retryCount = requestRetryCount.get(requestId) || 0;
            if (isDev) {
                log.info(`请求 ${requestId} 已重试 ${retryCount} 次`);
            }
            
            // 如果重试次数超过限制，不再尝试刷新token
            if (retryCount >= 3) {  // 最多重试3次
                if (isDev) {
                    log.info(`请求 ${requestId} 重试次数已达上限，不再重试`);
                }
                requestRetryCount.delete(requestId);  // 清理重试计数
                
                // 直接返回错误，不再尝试刷新token
                Message({
                    message: '请求失败，请稍后再试',
                    type: 'error',
                    duration: 10 * 1000
                });
                return Promise.reject(error);
            }
            
            // 增加重试计数
            requestRetryCount.set(requestId, retryCount + 1);
        }
        
        // 检查响应头部中是否有新token
        if (error.response && error.response.headers) {
            const newToken = error.response.headers['new-token'] || error.response.headers['New-Token'];
            if (newToken) {
                if (isDev) {
                    log.info('错误响应头中发现新token，更新token并重试请求');
                }
                setToken(newToken);
                // 使用新token重发请求
                const config = error.config;
                config.headers.Authorization = `Bearer ${newToken}`;
                return request(config);
            }
        }
        
        // 检查是否为token失效错误（不是401但返回token_not_valid）
        if (error.response && error.response.data && 
           (error.response.data.code === "token_not_valid" || 
            (error.response.data.detail && (
              error.response.data.detail.includes("token not valid") ||
              error.response.data.detail === "Given token not valid for any token type" ||
              error.response.data.detail === "Token is invalid or expired"
            )))) {
            
            if (isDev) {
                log.info('检测到token无效错误:', error.response.data);
            }
            
            // 如果是刷新token接口本身返回token无效，直接提示登录超时
            if (error.config && error.config.url && 
                (error.config.url.includes('/api/token/refresh/') || error.config.url.includes('/sso/refresh_token/'))) {
                
                // 清除token
                removeToken();
                removeRefreshToken();
                
                // 显示登录超时提示并提供重新登录选项
                if (!isShowingLoginDialog) {
                    isShowingLoginDialog = true;
                    MessageBox.confirm('登录已超时，请重新登录', '系统提示', {
                        confirmButtonText: '确定',
                        cancelButtonText: '取消',
                        type: 'warning'
                    }).then(() => {
                        location.href = '/index';
                        isShowingLoginDialog = false;
                    }).catch(() => {
                        if (isDev) {
                            log.info('用户选择留在当前页面');
                        }
                        isShowingLoginDialog = false;
                    });
                }
                
                return Promise.reject(new Error('登录已超时，请重新登录'));
            }
            
            // 检查是否已经是重试请求，避免无限循环
            if (error.config && error.config.isRetryRequest) {
                // 已经重试过但仍然失败，需要重新登录
                removeToken();
                removeRefreshToken();
                
                // 显示消息并提供重新登录选项
                if (!isShowingLoginDialog) {
                    isShowingLoginDialog = true;
                    MessageBox.confirm('登录已超时，请重新登录', '系统提示', {
                        confirmButtonText: '确定',
                        cancelButtonText: '取消',
                        type: 'warning'
                    }).then(() => {
                        location.href = '/index';
                        isShowingLoginDialog = false;
                    }).catch(() => {
                        if (isDev) {
                            log.info('用户选择留在当前页面');
                        }
                        isShowingLoginDialog = false;
                    });
                }
                
                return Promise.reject(new Error('登录已超时，请重新登录'));
            }
            
            // 其他接口的token无效错误，尝试刷新token
            if (isDev) {
                log.info('接口返回token无效，尝试刷新token后重试请求');
            }
            return handleTokenRefresh(error.config);
        }
        
        // 检查是否是invalid grant错误（密码错误）
        if (error.response && error.response.data && 
            (error.response.data.detail === "invalid grant" || 
             error.response.data.error === "invalid_grant" ||
             JSON.stringify(error.response.data).includes("invalid grant"))) {
            
            if (isDev) {
                log.info('检测到invalid grant错误，提示用户密码错误');
            }
            
            // 清除token
            removeToken();
            removeRefreshToken();
            
            // 使用MessageBox替代Message，仅在用户确认后跳转
            if (!isShowingLoginDialog) {
                isShowingLoginDialog = true;
                MessageBox.confirm('用户或密码错误，请重新输入', '系统提示', {
                    confirmButtonText: '重新登录',
                    cancelButtonText: '取消',
                    type: 'warning'
                }).then(() => {
                    location.href = '/index';
                    isShowingLoginDialog = false;
                }).catch(() => {
                    if (isDev) {
                        log.info('用户选择留在当前页面');
                    }
                    isShowingLoginDialog = false;
                });
            }
            
            return Promise.reject(new Error('用户或密码错误，请重新输入'));
        }
        
        // 检查是否是"No active account found with the given credentials"错误（用户不存在）
        if (error.response && error.response.data && 
            (error.response.data.detail === "No active account found with the given credentials" || 
             JSON.stringify(error.response.data).includes("No active account found with the given credentials"))) {
            
            if (isDev) {
                log.info('检测到用户名或密码错误');
            }
            
            // 清除token
            removeToken();
            removeRefreshToken();
            
            // 显示消息并提供重新登录选项
            if (!isShowingLoginDialog) {
                isShowingLoginDialog = true;
                MessageBox.confirm('用户名或密码错误，请重新输入', '系统提示', {
                    confirmButtonText: '确定',
                    cancelButtonText: '取消',
                    type: 'warning'
                }).then(() => {
                    location.href = '/index';
                    isShowingLoginDialog = false;
                }).catch(() => {
                    if (isDev) {
                        log.info('用户选择留在当前页面');
                    }
                    isShowingLoginDialog = false;
                });
            }
            
            return Promise.reject(new Error('用户名或密码错误，请重新输入'));
        }
        
        // 处理401错误，尝试刷新token而不是直接跳转登录页
        if (status === 401) {
            if (isDev) {
                log.info('检测到401错误，尝试刷新token');
            }
            
            // 检查是否已经是重试请求，避免无限循环
            if (error.config && error.config.isRetryRequest) {
                // 已经重试过但仍然返回401，说明刷新token无效，需要重新登录
                if (isDev) {
                    log.info('请求已重试过但仍返回401，需要重新登录');
                }
                removeToken();
                removeRefreshToken();
                
                // 显示消息并提供重新登录选项
                if (!isShowingLoginDialog) {
                    isShowingLoginDialog = true;
                    MessageBox.confirm('登录已超时，请重新登录', '系统提示', {
                        confirmButtonText: '确定',
                        cancelButtonText: '取消',
                        type: 'warning'
                    }).then(() => {
                        location.href = '/index';
                        isShowingLoginDialog = false;
                    }).catch(() => {
                        if (isDev) {
                            log.info('用户选择留在当前页面');
                        }
                        isShowingLoginDialog = false;
                    });
                }
                
                return Promise.reject(new Error('登录已超时，请重新登录'));
            }
            
            // 尝试刷新token
            if (isDev) {
                log.info('接口返回401，尝试刷新token后重试请求');
            }
            return handleTokenRefresh(error.config);
        }
        
        // 非token错误，清理重试计数
        if (requestId) {
            requestRetryCount.delete(requestId);
        }
        
        // 检查是否是token刷新后的请求但返回其他错误码（如400）
        if (error.response && error.config && error.config.isRetryRequest) {
            if (isDev) {
                log.info('刷新token后的请求返回错误:', error.response.status, error.response.data);
            }
            
            // 如果是400错误，说明请求数据有问题，而不是token问题
            if (error.response.status === 400) {
                let errorMsg = '请求数据有误';
                if (error.response.data) {
                    try {
                        // 尝试美化错误信息
                        errorMsg = typeof error.response.data === 'object' ? 
                            Object.entries(error.response.data)
                                .map(([key, value]) => `${key}: ${Array.isArray(value) ? value.join(', ') : value}`)
                                .join('; ') : 
                            error.response.data;
                    } catch (e) {
                        // 忽略错误
                    }
                }
                
                Message({
                    message: errorMsg,
                    type: 'error',
                    duration: 10 * 1000
                });
                
                return Promise.reject(error);
            }
        }
        
        let { message } = error;
        if (message == "Network Error") {
            message = "后端接口连接异常";
            Message({
                message: message,
                type: 'error',
                duration: 10 * 1000
            })
        } else if (message.includes("timeout")) {
            message = "系统接口请求超时";
            Message({
                message: message,
                type: 'error',
                duration: 10 * 1000
            })
        } else if (message.includes("Request failed with status code")) {
            // 除了401之外的其他错误码才显示消息
            if (!message.includes("401")) {
                message = "系统接口" + message.substr(message.length - 3) + "异常";
                Message({
                    message: message,
                    type: 'error',
                    duration: 10 * 1000
                })
            }
        }
     
        return Promise.reject(error)
    }
)


export default request

// 添加辅助函数，确保使用正确的API基础URL
export function getApiUrl(path) {
    if (!path) return '';
    
    // 获取基础URL
    const baseUrl = config.baseApi || window.baseUrl || '';
    
    // 如果已经是完整URL，检查是否需要替换
    if (path.startsWith('http://') || path.startsWith('https://')) {
        if (path.includes('localhost') && baseUrl) {
            if (isDev) {
                log.info('getApiUrl: 替换localhost URL:', path, '->', baseUrl);
            }
            const urlObj = new URL(path);
            return baseUrl + urlObj.pathname + urlObj.search;
        }
        return path;
    }
    
    // 相对路径，添加baseUrl
    if (baseUrl) {
        // 确保路径以/开头
        const normalizedPath = path.startsWith('/') ? path : '/' + path;
        return baseUrl + normalizedPath;
    }
    
    // 如果没有baseUrl，直接返回原路径
    return path;
}